home *** CD-ROM | disk | FTP | other *** search
/ Hardcore Visual Basic 5.0 (2nd Edition) / Hardcore Visual Basic 5.0 - Second Edition (1997)(Microsoft Press).iso / Source / Cpp4VB / WINTLB / REGISTRY.ODL < prev    next >
Text File  |  1996-04-11  |  22KB  |  714 lines
  1.  
  2. [
  3. uuid(54674054-3A82-101B-8181-00AA003743D3),
  4. helpstring("Registry"),
  5. #ifdef WIN32
  6. dllname("ADVAPI32.DLL")
  7. #else
  8. dllname("SHELL.DLL")
  9. #endif
  10. ]
  11. module Registry {
  12.  
  13.     // Kind of weird place for this, but it must go in ADVAPI32
  14.     [
  15.     usesgetlasterror,
  16.     entry("GetUserNameA"),
  17.     helpstring("Gets the user name"),
  18.     ]
  19.     BOOL WINAPI GetUserName([in, out] LPSTR lpBuffer,
  20.                             [in, out] DWORD FAR * nSize);
  21.  
  22.     //
  23.     // Requested Key access mask type.
  24.     //
  25.  
  26.     // typedef ACCESS_MASK REGSAM;
  27.  
  28.     //
  29.     // Type definitions.
  30.     //
  31.  
  32.     //
  33.     // Reserved Key Handles.
  34.     //
  35.  
  36.     const long HKEY_CLASSES_ROOT            = 0x80000000;
  37.     const long HKEY_CURRENT_USER            = 0x80000001;
  38.     const long HKEY_LOCAL_MACHINE           = 0x80000002;
  39.     const long HKEY_USERS                   = 0x80000003;
  40.     const long HKEY_PERFORMANCE_DATA        = 0x80000004;
  41.     const long HKEY_CURRENT_CONFIG          = 0x80000005;
  42.     const long HKEY_DYN_DATA                = 0x80000006;
  43.  
  44.     const long PROVIDER_KEEPS_VALUE_LENGTH = 0x1;
  45.  
  46.     //
  47.     // Predefined Value Types.
  48.     //
  49.  
  50.     [ helpstring("Registry types: No value type") ]
  51.     const long REG_NONE                     = 0;
  52.     [ helpstring("Registry types: Null-terminated string (Unicode in 32-bit)") ]
  53.     const long REG_SZ                       = 1;
  54.     #if WIN32
  55.     [ helpstring("Registry types: Null-terminated string with environment variable references") ]
  56.     const long REG_EXPAND_SZ                = 2;
  57.     [ helpstring("Registry types: Free form binary") ]
  58.     const long REG_BINARY                   = 3;
  59.     [ helpstring("Registry types: 32-bit number") ]
  60.     const long REG_DWORD                    = 4;
  61.     [ helpstring("Registry types: 32-bit number") ]
  62.     const long REG_DWORD_LITTLE_ENDIAN      = 4;
  63.     [ helpstring("Registry types: 32-bit number") ]
  64.     const long REG_DWORD_BIG_ENDIAN         = 5;
  65.     [ helpstring("Registry types: Symbolic Link (Unicode)") ]
  66.     const long REG_LINK                     = 6;
  67.     [ helpstring("Registry types: Multiple Unicode strings") ]
  68.     const long REG_MULTI_SZ                 = 7;
  69.     [ helpstring("Registry types: Resource list in the resource map") ]
  70.     const long REG_RESOURCE_LIST            = 8;
  71.     [ helpstring("Registry types: Resource list in the hardware description") ]
  72.     const long REG_FULL_RESOURCE_DESCRIPTOR = 9;
  73.     const long REG_RESOURCE_REQUIREMENTS_LIST   = 10;
  74.  
  75.     // Registry Specific Access Rights.
  76.     //
  77.  
  78.     [ helpstring("Registry access: Allow value query") ]
  79.     const long KEY_QUERY_VALUE         = 0x0001;
  80.     [ helpstring("Registry access: Allow set subkey data") ]
  81.     const long KEY_SET_VALUE           = 0x0002;
  82.     [ helpstring("Registry access: Allow create subkey") ]
  83.     const long KEY_CREATE_SUB_KEY      = 0x0004;
  84.     [ helpstring("Registry access: Allow subkey enumeration") ]
  85.     const long KEY_ENUMERATE_SUB_KEYS  = 0x0008;
  86.     [ helpstring("Registry access: Allow change notification") ]
  87.     const long KEY_NOTIFY              = 0x0010;
  88.     [ helpstring("Registry access: Allow symbolic link creation") ]
  89.     const long KEY_CREATE_LINK         = 0x0020;
  90.     [ helpstring("Registry access: Allow query, enumerate, and notify") ]
  91.     const long KEY_READ                = 0x00020009;
  92.     [ helpstring("Registry access: Allow subkey create and set value") ]
  93.     const long KEY_WRITE               = 0x00020006;
  94.     [ helpstring("Registry access: Allow read") ]
  95.     const long KEY_EXECUTE             = 0x00020009;
  96.     [ helpstring("Registry access: Allow anything") ]
  97.     const long KEY_ALL_ACCESS          = 0x000F003F;
  98.  
  99.     //
  100.     // Open/Create Options
  101.     //
  102.  
  103.     // Parameter is reserved
  104.     const long REG_OPTION_RESERVED         = 0x00000000;
  105.     // Key is preserved when system is rebooted
  106.     const long REG_OPTION_NON_VOLATILE     = 0x00000000;
  107.     // Key is not preserved when system is rebooted
  108.     const long REG_OPTION_VOLATILE         = 0x00000001;
  109.     // Created key is a symbolic link
  110.     const long REG_OPTION_CREATE_LINK      = 0x00000002;
  111.     // open for backup or restore special access rules privilege required
  112.     const long REG_OPTION_BACKUP_RESTORE   = 0x00000004;
  113.  
  114.     const long REG_LEGAL_OPTION            = 0x00000007;
  115.  
  116.     //
  117.     // Key creation/open disposition
  118.     //
  119.  
  120.     // New Registry Key created
  121.     const long REG_CREATED_NEW_KEY         = 0x00000001;
  122.     // Existing Key opened
  123.     const long REG_OPENED_EXISTING_KEY     = 0x00000002;
  124.  
  125.     //
  126.     // Key restore flags
  127.     //
  128.  
  129.     // Restore whole hive volatile
  130.     const long REG_WHOLE_HIVE_VOLATILE     = 0x00000001;
  131.     // Unwind changes to last flush
  132.     const long REG_REFRESH_HIVE            = 0x00000002;
  133.  
  134.     //
  135.     // Notify filter values
  136.     //
  137.     // Create or delete (child)
  138.     const long REG_NOTIFY_CHANGE_NAME          = 0x00000001;
  139.     const long REG_NOTIFY_CHANGE_ATTRIBUTES    = 0x00000002;
  140.     // time stamp
  141.     const long REG_NOTIFY_CHANGE_LAST_SET      = 0x00000004;
  142.     const long REG_NOTIFY_CHANGE_SECURITY      = 0x00000008;
  143.  
  144.     const long REG_LEGAL_CHANGE_FILTER         = 0x0000000F;
  145.  
  146.     #endif // WIN32
  147.  
  148.     /*
  149.     struct val_context {
  150.         int valuelen;       // the total length of this value
  151.         LPVOID value_context;   // provider's context
  152.         LPVOID val_buff_ptr;    // where in the ouput buffer the value is.
  153.     };
  154.  
  155.     typedef struct val_context FAR *PVALCONTEXT;
  156.  
  157.     typedef struct pvalueA {           // Provider supplied value/context.
  158.         LPSTR   pv_valuename;          // The value name pointer
  159.         int pv_valuelen;
  160.         LPVOID pv_value_context;
  161.         DWORD pv_type;
  162.     }PVALUEA, FAR *PPVALUEA;
  163.  
  164.     typedef
  165.     DWORD _cdecl
  166.     QUERYHANDLER (LPVOID keycontext, PVALCONTEXT val_list, DWORD num_vals,
  167.               LPVOID outputbuffer, DWORD FAR *total_outlen, DWORD input_blen);
  168.  
  169.     typedef QUERYHANDLER FAR *PQUERYHANDLER;
  170.  
  171.     typedef struct provider_info {
  172.         PQUERYHANDLER pi_R0_1val;
  173.         PQUERYHANDLER pi_R0_allvals;
  174.         PQUERYHANDLER pi_R3_1val;
  175.         PQUERYHANDLER pi_R3_allvals;
  176.         DWORD pi_flags;    // capability flags (none defined yet).
  177.         LPVOID pi_key_context;
  178.     }REG_PROVIDER;
  179.  
  180.     typedef struct provider_info FAR *PPROVIDER;
  181.  
  182.     typedef struct value_entA {
  183.         LPSTR   ve_valuename;
  184.         DWORD ve_valuelen;
  185.         DWORD ve_valueptr;
  186.         DWORD ve_type;
  187.     }VALENTA, FAR *PVALENTA;
  188.     */
  189.  
  190.     //
  191.     // Default values for parameters that do not exist in the Win 3.1
  192.     // compatible APIs.
  193.     //
  194.  
  195.     //         #define WIN31_CLASS              NULL
  196.  
  197.     //
  198.     // API Prototypes.
  199.     //
  200.  
  201.     [
  202.     usesgetlasterror,
  203.     entry("RegCloseKey"),
  204.     helpstring("Releases the handle of specified registry key"),
  205.     ]
  206.     LONG WINAPI RegCloseKey([in] HKEY hKey);
  207.  
  208.     #if WIN32
  209.     [
  210.     usesgetlasterror,
  211.     entry("RegConnectRegistryA"),
  212.     helpstring("Establishes a connection to predefined registry handle on another computer"),
  213.     ]
  214.     LONG WINAPI RegConnectRegistry(
  215.         [in, out] LPSTR lpMachineName,
  216.         [in] HKEY hKey,
  217.         [in, out] HKEY FAR * phkResult
  218.         );
  219.     #endif
  220.  
  221.     [
  222.     usesgetlasterror,
  223.     #if WIN32
  224.     entry("RegCreateKeyA"),
  225.     #else
  226.     entry("RegCreateKey"),
  227.     #endif
  228.     helpstring("Opens specified registry key if it already exists, or creates it if it doesn't exist"),
  229.     ]
  230.     LONG WINAPI RegCreateKey(
  231.         [in] HKEY hKey,
  232.         [in] LPCSTR lpSubKey,
  233.         [in, out] HKEY FAR * phkResult
  234.         );
  235.  
  236.     #if WIN32
  237.     [
  238.     usesgetlasterror,
  239.     entry("RegCreateKeyExA"),
  240.     helpstring("Opens specified registry key if it already exists, or creates it if it doesn't exist"),
  241.     ]
  242.     LONG WINAPI RegCreateKeyEx(
  243.         [in] HKEY hKey,
  244.         [in] LPCSTR lpSubKey,
  245.         [in] DWORD Reserved,
  246.         [in, out] LPSTR lpClass,
  247.         [in] DWORD dwOptions,
  248.         [in] REGSAM samDesired,
  249.         [in] LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  250.         [in, out] HKEY FAR * phkResult,
  251.         [in, out] DWORD FAR * lpdwDisposition
  252.         );
  253.     #endif
  254.  
  255.     [
  256.     usesgetlasterror,
  257.     #if WIN32
  258.     entry("RegDeleteKeyA"),
  259.     #else
  260.     entry("RegDeleteKey"),
  261.     #endif
  262.     helpstring("Deletes specified registry key and all its descendents (except under Windows NT where the key can't have descendants)"),
  263.     ]
  264.     LONG WINAPI RegDeleteKey(
  265.         [in] HKEY hKey,
  266.         [in] LPCSTR lpSubKey
  267.         );
  268.  
  269.     #if WIN32
  270.     [
  271.     usesgetlasterror,
  272.     entry("RegDeleteValueA"),
  273.     helpstring("Removes a named value from the specified registry key"),
  274.     ]
  275.     LONG WINAPI RegDeleteValue(
  276.         [in] HKEY hKey,
  277.         [in] LPCSTR lpValueName
  278.         );
  279.     #endif
  280.  
  281.     [
  282.     usesgetlasterror,
  283.     #if WIN32
  284.     entry("RegEnumKeyA"),
  285.     #else
  286.     entry("RegEnumKey"),
  287.     #endif
  288.     helpstring("Enumerates subkeys of an open registry key one at a time, retrieving subkey names"),
  289.     ]
  290.     LONG WINAPI RegEnumKey(
  291.         [in] HKEY hKey,
  292.         [in] DWORD dwIndex,
  293.         [in, out] LPSTR lpName,
  294.         [in] DWORD cbName
  295.         );
  296.  
  297.     #if WIN32 
  298.     [
  299.     usesgetlasterror,
  300.     entry("RegEnumKeyExA"),
  301.     helpstring("Enumerates subkeys of an open registry key one at a time, retrieving subkey information"),
  302.     ]
  303.     LONG WINAPI RegEnumKeyEx(
  304.         [in] HKEY hKey,
  305.         [in] DWORD dwIndex,
  306.         [in, out] LPSTR lpName,
  307.         [in, out] DWORD FAR * lpcbName,
  308.         [in] DWORD lpReserved,
  309.         [in, out] LPSTR lpClass,
  310.         [in, out] DWORD FAR * lpcbClass,
  311.         [in, out] DWORD FAR * /* PFILETIME */ lpftLastWriteTime
  312.         );
  313.  
  314.     [
  315.     usesgetlasterror,
  316.     entry("RegEnumValueA"),
  317.     helpstring("Enumerates the values for an open registry key one at a time, retrieving the size of the name and data block for each")
  318.     ]
  319.     LONG WINAPI RegEnumValue(
  320.         [in] HKEY hKey,
  321.         [in] DWORD dwIndex,
  322.         [in, out] LPSTR lpValueName,
  323.         [in, out] DWORD FAR * lpcbValueName,
  324.         [in] DWORD lpReserved,
  325.         [in, out] DWORD FAR * lpType,
  326.         [in] DWORD lpData,
  327.         [in, out] DWORD FAR * lpcbData
  328.         );
  329.  
  330.     [
  331.     usesgetlasterror,
  332.     entry("RegEnumValueA"),
  333.     helpstring("Enumerates the values for an open registry key one at a time, retrieving the name and byte data for each")
  334.     ]
  335.     LONG WINAPI RegEnumValueByte(
  336.         [in] HKEY hKey,
  337.         [in] DWORD dwIndex,
  338.         [in, out] LPSTR lpValueName,
  339.         [in, out] DWORD FAR * lpcbValueName,
  340.         [in] DWORD lpReserved,
  341.         [in, out] DWORD FAR * lpType,
  342.         [in, out] BYTE FAR * lpData,
  343.         [in, out] DWORD FAR * lpcbData
  344.         );
  345.     [
  346.     usesgetlasterror,
  347.     entry("RegEnumValueA"),
  348.     helpstring("Enumerates the values for an open registry key one at a time, retrieving the name and string data for each")
  349.     ]
  350.     LONG WINAPI RegEnumValueStr(
  351.         [in] HKEY hKey,
  352.         [in] DWORD dwIndex,
  353.         [in, out] LPSTR lpValueName,
  354.         [in, out] DWORD FAR * lpcbValueName,
  355.         [in] DWORD lpReserved,
  356.         [in, out] DWORD FAR * lpType,
  357.         [in, out] LPSTR lpData,
  358.         [in, out] DWORD FAR * lpcbData
  359.         );
  360.     [
  361.     usesgetlasterror,
  362.     entry("RegEnumValueA"),
  363.     helpstring("Enumerates the values for an open registry key one at a time, retrieving the name and integer data for each")
  364.     ]
  365.     LONG WINAPI RegEnumValueInt(
  366.         [in] HKEY hKey,
  367.         [in] DWORD dwIndex,
  368.         [in, out] LPSTR lpValueName,
  369.         [in, out] DWORD FAR * lpcbValueName,
  370.         [in] DWORD lpReserved,
  371.         [in, out] DWORD FAR * lpType,
  372.         [in, out] DWORD FAR * lpData,
  373.         [in, out] DWORD FAR * lpcbData
  374.         );
  375.  
  376.     [
  377.     usesgetlasterror,
  378.     entry("RegFlushKey"),
  379.     helpstring("Writes attributes of an open key into the registry"),
  380.     ]
  381.     LONG WINAPI RegFlushKey([in] HKEY hKey);
  382.  
  383.     /*
  384.     [
  385.     usesgetlasterror,
  386.     entry(""),
  387.     helpstring(""),
  388.     ]
  389.     LONG WINAPI RegGetKeySecurity (
  390.         [in] HKEY hKey,
  391.         [in] SECURITY_INFORMATION SecurityInformation,
  392.         [in] PSECURITY_DESCRIPTOR pSecurityDescriptor,
  393.         [in, out] DWORD FAR * lpcbSecurityDescriptor
  394.         );
  395.     */
  396.  
  397.     [
  398.     usesgetlasterror,
  399.     entry("RegLoadKeyA"),
  400.     helpstring("Creates a subkey and stores registration information from a specified file into that subkey"),
  401.     ]
  402.     LONG WINAPI RegLoadKey(
  403.         [in] HKEY   hKey,
  404.         [in] LPCSTR lpSubKey,
  405.         [in] LPCSTR lpFile
  406.         );
  407.  
  408.     [
  409.     usesgetlasterror,
  410.     entry("RegNotifyChangeKeyValue"),
  411.     helpstring("Indicates when a registry key or any of its subkeys has changed"),
  412.     ]
  413.     LONG WINAPI RegNotifyChangeKeyValue(
  414.         [in] HKEY hKey,
  415.         [in] BOOL bWatchSubtree,
  416.         [in] DWORD dwNotifyFilter,
  417.         [in] HANDLE hEvent,
  418.         [in] BOOL fAsynchronus
  419.         );
  420.     #endif // WIN32
  421.  
  422.     [
  423.     usesgetlasterror,
  424.     #if WIN32
  425.     entry("RegOpenKeyA"),
  426.     #else
  427.     entry("RegOpenKey"),
  428.     #endif
  429.     helpstring("Opens the specified key"),
  430.     ]
  431.     LONG WINAPI RegOpenKey(
  432.         [in] HKEY hKey,
  433.         [in] LPCSTR lpSubKey,
  434.         [in, out] HKEY FAR * phkResult
  435.         );
  436.  
  437.     #if WIN32
  438.     [
  439.     usesgetlasterror,
  440.     entry("RegOpenKeyExA"),
  441.     helpstring("Opens the specified key"),
  442.     ]
  443.     LONG WINAPI RegOpenKeyEx(
  444.         [in] HKEY hKey,
  445.         [in] LPCSTR lpSubKey,
  446.         [in] DWORD ulOptions,
  447.         [in] REGSAM samDesired,
  448.         [in, out] HKEY FAR * phkResult
  449.         );
  450.     #endif
  451.  
  452.     [
  453.     usesgetlasterror,
  454.     entry("RegQueryInfoKeyA"),
  455.     helpstring("Retrieves information about a registry key"),
  456.     ]
  457.     LONG WINAPI RegQueryInfoKey(
  458.         [in] HKEY hKey,
  459.         [in, out] LPSTR lpClass,
  460.         [in, out] DWORD FAR * lpcbClass,
  461.         [in] DWORD lpReserved,
  462.         [in, out] DWORD FAR * lpcSubKeys,
  463.         [in, out] DWORD FAR * lpcbMaxSubKeyLen,
  464.         [in, out] DWORD FAR * lpcbMaxClassLen,
  465.         [in, out] DWORD FAR * lpcValues,
  466.         [in, out] DWORD FAR * lpcbMaxValueNameLen,
  467.         [in, out] DWORD FAR * lpcbMaxValueLen,
  468.         [in, out] DWORD FAR * lpcbSecurityDescriptor,
  469.         [in, out] DWORD FAR * /* PFILETIME */ lpftLastWriteTime
  470.         );
  471.  
  472.     [
  473.     usesgetlasterror,
  474.     #if WIN32
  475.     entry("RegQueryValueA"),
  476.     #else
  477.     entry("RegQueryValue"),
  478.     #endif
  479.     helpstring("Retrieves value associated with u13150named value of a specified registry key"),
  480.     ]
  481.     LONG WINAPI RegQueryValue(
  482.         [in] HKEY hKey,
  483.         [in] LPCSTR lpSubKey,
  484.         [in, out] LPSTR lpValue,
  485.         [in, out] LONG FAR * lpcbValue
  486.         );
  487.  
  488.     #if WIN32
  489.     [
  490.     usesgetlasterror,
  491.     entry("RegQueryValueExA"),
  492.     helpstring("Retrieves byte array value associated with a named or unnamed value of a specified registry key"),
  493.     ]
  494.     LONG WINAPI RegQueryValueEx([in] HKEY hKey,
  495.                                 [in] LPCSTR lpValueName,
  496.                                 [in] DWORD lpReserved,
  497.                                 [in] DWORD FAR * lpType,
  498.                                 [in] DWORD lpData,
  499.                                 [in, out] DWORD FAR * lpcbData);
  500.  
  501.     [
  502.     usesgetlasterror,
  503.     entry("RegQueryValueExA"),
  504.     helpstring("Retrieves byte array value associated with a named or unnamed value of a specified registry key"),
  505.     ]
  506.     LONG WINAPI RegQueryValueExByte([in] HKEY hKey,
  507.                                     [in] LPCSTR lpValueName,
  508.                                     [in] DWORD lpReserved,
  509.                                     [in] DWORD FAR * lpType,
  510.                                     [in, out] BYTE FAR * lpData,
  511.                                     [in, out] DWORD FAR * lpcbData);
  512.  
  513.     [
  514.     usesgetlasterror,
  515.     entry("RegQueryValueExA"),
  516.     helpstring("Retrieves byte array value associated with a named or unnamed value of a specified registry key"),
  517.     ]
  518.     LONG WINAPI RegQueryValueExStr([in] HKEY hKey,
  519.                                    [in] LPCSTR lpValueName,
  520.                                    [in] DWORD lpReserved,
  521.                                    [in] DWORD FAR * lpType,
  522.                                    [in, out] LPSTR lpData,
  523.                                    [in, out] DWORD FAR * lpcbData);
  524.  
  525.     [
  526.     usesgetlasterror,
  527.     entry("RegQueryValueExA"),
  528.     helpstring("Retrieves Long value associated with a named or unnamed value of a specified registry key"),
  529.     ]
  530.     LONG WINAPI RegQueryValueExInt([in] HKEY hKey,
  531.                                    [in] LPCSTR lpValueName,
  532.                                    [in] DWORD lpReserved,
  533.                                    [in] DWORD FAR * lpType,
  534.                                    [in, out] DWORD FAR * lpData,
  535.                                    [in, out] DWORD FAR * lpcbData);
  536.  
  537.     // Win95 only
  538.     /*
  539.     [
  540.     usesgetlasterror,
  541.     entry("RegQueryMultipleValuesA"),
  542.     helpstring(""),
  543.     ]
  544.     LONG WINAPI RegQueryMultipleValues(
  545.         [in] HKEY hKey,
  546.         [in, out] PVALENTA val_list,
  547.         [in] DWORD num_vals,
  548.         [in, out] LPSTR lpValueBuf,
  549.         [in, out] DWORD FAR * ldwTotsize
  550.         );
  551.     */
  552.  
  553.     [
  554.     usesgetlasterror,
  555.     entry("RegReplaceKeyA"),
  556.     helpstring("Replaces the file backing a key and all its subkeys with another file, so that when the system is next started, the key and subkeys will have the values stored in the new file"),
  557.     ]
  558.     LONG WINAPI RegReplaceKey(
  559.         [in] HKEY    hKey,
  560.         [in] LPCSTR lpSubKey,
  561.         [in] LPCSTR lpNewFile,
  562.         [in] LPCSTR lpOldFile
  563.         );
  564.  
  565.     [
  566.     usesgetlasterror,
  567.     entry("RegSaveKeyA"),
  568.     helpstring("Reads registry information in a file and copies it over a key in the form of a key and multiple levels of subkeys"),
  569.     ]
  570.     LONG WINAPI RegRestoreKey(
  571.         [in] HKEY hKey,
  572.         [in] LPCSTR lpFile,
  573.         [in] DWORD  dwFlags
  574.         );
  575.  
  576.     [
  577.     usesgetlasterror,
  578.     entry("RegSaveKeyA"),
  579.     helpstring("Saves a key and all of its subkeys and values to a file"),
  580.     ]
  581.     LONG WINAPI RegSaveKey(
  582.         [in] HKEY hKey,
  583.         [in] LPCSTR lpFile,
  584.         [in] LPSECURITY_ATTRIBUTES lpSecurityAttributes
  585.         );
  586.  
  587.     [
  588.     usesgetlasterror,
  589.     entry("RegSetKeySecurity"),
  590.     helpstring("Sets the security of an open registry key"),
  591.     ]
  592.     LONG WINAPI RegSetKeySecurity(
  593.         [in] HKEY hKey,
  594.         [in] DWORD /* SECURITY_INFORMATION */ SecurityInformation,
  595.         [in] DWORD /* PSECURITY_DESCRIPTOR */ pSecurityDescriptor
  596.         );
  597.     #endif // WIN32
  598.  
  599.     [
  600.     usesgetlasterror,
  601.     #if WIN32
  602.     entry("RegSetValueA"),
  603.     #else
  604.     entry("RegSetValue"),
  605.     #endif
  606.     helpstring("Associates a text value with specified key"),
  607.     ]
  608.     LONG WINAPI RegSetValue(
  609.         [in] HKEY hKey,
  610.         [in] LPCSTR lpSubKey,
  611.         [in] DWORD dwType,
  612.         [in] LPCSTR lpData,
  613.         [in] DWORD cbData
  614.         );
  615.  
  616.     #if WIN32
  617.     [
  618.     usesgetlasterror,
  619.     entry("RegSetValueExA"),
  620.     helpstring("Associates a value (optionally named) with specified key"),
  621.     ]
  622.     LONG WINAPI RegSetValueEx(
  623.         [in] HKEY hKey,
  624.         [in] LPCSTR lpValueName,
  625.         [in] DWORD Reserved,
  626.         [in] DWORD dwType,
  627.         [in] BYTE FAR * lpData,
  628.         [in] DWORD cbData
  629.         );
  630.  
  631.     [
  632.     usesgetlasterror,
  633.     entry("RegSetValueExA"),
  634.     helpstring("Associates a value (optionally named) with specified key"),
  635.     ]
  636.     LONG
  637.     WINAPI
  638.     RegSetValueExByte(
  639.         [in] HKEY hKey,
  640.         [in] LPCSTR lpValueName,
  641.         [in] DWORD Reserved,
  642.         [in] DWORD dwType,
  643.         [in] BYTE FAR * lpData,
  644.         [in] DWORD cbData
  645.         );
  646.  
  647.     [
  648.     usesgetlasterror,
  649.     entry("RegSetValueExA"),
  650.     helpstring("Associates a value (optionally named) with specified key"),
  651.     ]
  652.     LONG
  653.     WINAPI
  654.     RegSetValueExStr(
  655.         [in] HKEY hKey,
  656.         [in] LPCSTR lpValueName,
  657.         [in] DWORD Reserved,
  658.         [in] DWORD dwType,
  659.         [in] LPSTR lpData,
  660.         [in] DWORD cbData
  661.         );
  662.  
  663.     [
  664.     usesgetlasterror,
  665.     entry("RegSetValueExA"),
  666.     helpstring("Associates a value (optionally named) with specified key"),
  667.     ]
  668.     LONG WINAPI RegSetValueExInt(
  669.         [in] HKEY hKey,
  670.         [in] LPCSTR lpValueName,
  671.         [in] DWORD Reserved,
  672.         [in] DWORD dwType,
  673.         [in] DWORD FAR * lpData,
  674.         [in] DWORD cbData
  675.         );
  676.  
  677.     [
  678.     usesgetlasterror,
  679.     entry("RegUnLoadKeyA"),
  680.     helpstring("Unloads the specified key and subkeys from the registry"),
  681.     ]
  682.     LONG WINAPI RegUnLoadKey(
  683.         [in] HKEY   hKey,
  684.         [in] LPCSTR lpSubKey
  685.         );
  686.  
  687.     /*
  688.     // Remoteable System Shutdown APIs
  689.     [
  690.     usesgetlasterror,
  691.     entry("InitiateSystemShutdownA"),
  692.     helpstring(""),
  693.     ]
  694.     BOOL WINAPI InitiateSystemShutdown(
  695.         [in, out] LPSTR lpMachineName,
  696.         [in, out] LPSTR lpMessage,
  697.         [in] DWORD dwTimeout,
  698.         [in] BOOL bForceAppsClosed,
  699.         [in] BOOL bRebootAfterShutdown
  700.         );
  701.  
  702.     [
  703.     usesgetlasterror,
  704.     entry("AbortSystemShutdownA"),
  705.     helpstring(""),
  706.     ]
  707.     BOOL WINAPI AbortSystemShutdown(
  708.         [in, out] LPSTR lpMachineName
  709.         );
  710.     */
  711.     #endif // WIN32
  712.  
  713. }
  714.